'use strict';

const Service = require('egg').Service;

class AdminRoleService extends Service {

    /**
     * 获取所有的数据
     * @param {*} args 查询限制条件 {key:values}
     */
    async getModuleList(args) {
        let whereObj = {};
        Object.keys(args).forEach((keyName) => {
            if (!whereObj[keyName]) {
                whereObj[keyName] = args[keyName];
            }
        });
        const selectInfo = await this.ctx.model.AdminRole.findAll({
            where: whereObj
        });
        if (!selectInfo) {
            this.ctx.throw(0, "查无数据,请您重试!!")
        }
        return selectInfo;
    };

    /**
     * 根据限制条件获取一条数据
     * @param {*} args 查询限制条件 {key:values}
     */
    async getModuleByWhere(args) {
        let whereObj = {};
        Object.keys(args).forEach((keyName) => {
            if (!whereObj[keyName]) {
                whereObj[keyName] = args[keyName];
            }
        });
        const selectInfo = await this.ctx.model.AdminRole.findOne({
            where: whereObj
        });
        if (!selectInfo) {
            this.ctx.throw(0, "查无数据,请您重试!!")
        }
        return selectInfo;
    };

    /**
     * 根据主键ID获取一条数据
     * @param {*} id id
     */
    async getModuleByPk(id) {
        const selectInfo = await this.ctx.model.AdminRole.findByPk(id);
        if (!selectInfo) {
            this.ctx.throw(0, "查无数据,请您重试!!")
        }
        return selectInfo;
    };

    /**
     * 分页查询数据
     * @param {*} offset 索引
     * @param {*} limit 页大小
     * @param {*} args 查询限制条件 {key:values}
     */
    async getModuleListByPage(offset, limit, args) {
        let whereObj = {};
        Object.keys(args).forEach((keyName) => {
            if (!whereObj[keyName]) {
                whereObj[keyName] = args[keyName];
            }
        });
        const selectInfo = await this.ctx.model.AdminRole.findAndCountAll({
            where: whereObj,
            offset: offset,
            limit: limit
        });
        if (!selectInfo) {
            this.ctx.throw(0, "查无数据,请您重试!!")
        }
        return selectInfo;
    };

    /**
     * 新增数据
     * @param {*} timeList 需要创建的时间参数 字符串数组
     * @param {*} dataList 需要新增的字段值对象，不包含时间类型
     */
    async postCreateInfo(timeList, dataList) {
        let insertObj = {}; //新增对象数据
        Object.keys(dataList).forEach((keyName) => {
            if (!insertObj[keyName]) {
                if (keyName.toLowerCase() === "id")
                    insertObj[keyName] = this.ctx.helper.getGuid16();
                else
                    insertObj[keyName] = dataList[keyName];
            }
        });
        if (timeList !== undefined && timeList.length > 0) {
            timeList.forEach((keyName) => {
                if (!insertObj[keyName]) {
                    insertObj[keyName] = new Date()
                }
            })
        }

        return this.ctx.model.AdminRole.create(insertObj);
    };

    /**
     * 更新数据
     * @param {*} id 需要更新的元素ID
     * @param {*} timeList 需要创建的时间参数 字符串数组
     * @param {*} dataList 需要新增的字段值对象，不包含时间类型
     */
    async postUpdateInfo(id, timeList, dataList) {
        let updateObj = {}; //更新对象数据
        const selectInfo = await this.ctx.model.AdminRole.findByPk(id);
        if (!selectInfo) {
            this.ctx.throw(0, "非法操作=>ID不对!!");
        }
        Object.keys(dataList).forEach((keyName) => {
            if (!updateObj[keyName]) {
                updateObj[keyName] = dataList[keyName];
            }
        });
        if (timeList !== undefined && timeList.length > 0) {
            timeList.forEach((keyName) => {
                if (!updateObj[keyName]) {
                    updateObj[keyName] = new Date()
                }
            })
        }
        return selectInfo.update(updateObj);
    };

    /**
     * 根据限制条件删除对应的数据
     * @param {*} args 查询限制条件 {key:values}
     */
    async postRemoveInfoByWhere(args) {
        let whereObj = {};
        Object.keys(args).forEach((keyName) => {
            if (!whereObj[keyName]) {
                whereObj[keyName] = args[keyName];
            }
        });
        let result=0;
        await this.ctx.model.AdminRole.destroy({ where: whereObj }).then(res => {
            result= 1;
        }).catch(err => {
            result= 0;
        });
        return result;
    };

    /**
     * 根据ID删除对应的数据
     * @param {*} id 元素ID
     */
    async postRemoveInfoByPk(id) {
        const selectInfo = await this.ctx.model.AdminRole.findByPk(id);
        if (!selectInfo) {
            this.ctx.throw(0, "非法操作=>ID不对!!");
        }
        let result=0;
        await selectInfo.destroy().then(res => {
            result= 1;
        }).catch(err => {
            result= 0;
        });
        return result;
    };
}

module.exports = AdminRoleService;
